#ifndef __iFriends_H__
#define __iFriends_H__
#include <string>
#include <list>
#include <vector>
#include <map>
#include <cstring>
#include <stdint.h>

//#include "other_idl.h"

struct iSocialUserSeqInfo {
	uint64_t	socialid;
	uint32_t	userseq;
	uint16_t	is_delete;
	iSocialUserSeqInfo()	{
		socialid = 0;
		userseq = 0;
		is_delete = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint64_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint64_t*)(*_buf_)) = socialid; (*_buf_) += sizeof(uint64_t);
		(*(uint32_t*)(*_buf_)) = userseq; (*_buf_) += sizeof(uint32_t);
		(*(uint16_t*)(*_buf_)) = is_delete; (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint64_t) > nSize) { return false; }	std::memcpy(&socialid, *_buf_, sizeof(uint64_t));	(*_buf_) += sizeof(uint64_t); nSize -= sizeof(uint64_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&userseq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&is_delete, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //iSocialUserSeqInfo
struct iSocialUserSeqInfo_Serializer {
	static bool Store(char** _buf_, const iSocialUserSeqInfo& obj) { return obj.Store(_buf_); }
	static bool Load(iSocialUserSeqInfo& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const iSocialUserSeqInfo& obj) { return obj.Size(); }
};
struct iGameUserSeqInfo {
	uint64_t	socialid;
	uint32_t	userseq;
	iGameUserSeqInfo()	{
		socialid = 0;
		userseq = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint64_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint64_t*)(*_buf_)) = socialid; (*_buf_) += sizeof(uint64_t);
		(*(uint32_t*)(*_buf_)) = userseq; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint64_t) > nSize) { return false; }	std::memcpy(&socialid, *_buf_, sizeof(uint64_t));	(*_buf_) += sizeof(uint64_t); nSize -= sizeof(uint64_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&userseq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //iGameUserSeqInfo
struct iGameUserSeqInfo_Serializer {
	static bool Store(char** _buf_, const iGameUserSeqInfo& obj) { return obj.Store(_buf_); }
	static bool Load(iGameUserSeqInfo& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const iGameUserSeqInfo& obj) { return obj.Size(); }
};
struct iSocialFriendInfo {
	uint32_t	userseq;
	uint16_t	no_play_period;
	uint16_t	is_connect_requested;
	uint16_t	is_heart_sent;
	iSocialFriendInfo()	{
		userseq = 0;
		no_play_period = 0;
		is_connect_requested = 0;
		is_heart_sent = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = userseq; (*_buf_) += sizeof(uint32_t);
		(*(uint16_t*)(*_buf_)) = no_play_period; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = is_connect_requested; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = is_heart_sent; (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&userseq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&no_play_period, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&is_connect_requested, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&is_heart_sent, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //iSocialFriendInfo
struct iSocialFriendInfo_Serializer {
	static bool Store(char** _buf_, const iSocialFriendInfo& obj) { return obj.Store(_buf_); }
	static bool Load(iSocialFriendInfo& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const iSocialFriendInfo& obj) { return obj.Size(); }
};
struct iGameFriendInfo {
	uint32_t	userseq;
	std::string	nickname;
	std::string	profile_url;
	uint16_t	no_play_period;
	uint16_t	is_connect_requested;
	uint16_t	is_heart_sent;
	iGameFriendInfo()	{
		userseq = 0;
		no_play_period = 0;
		is_connect_requested = 0;
		is_heart_sent = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int32_t); nSize += nickname.length();
		nSize += sizeof(int32_t); nSize += profile_url.length();
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = userseq; (*_buf_) += sizeof(uint32_t);
		(*(int32_t*)(*_buf_)) = (int32_t)nickname.length(); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, nickname.c_str(), nickname.length());
		(*_buf_) += nickname.length();
		(*(int32_t*)(*_buf_)) = (int32_t)profile_url.length(); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, profile_url.c_str(), profile_url.length());
		(*_buf_) += profile_url.length();
		(*(uint16_t*)(*_buf_)) = no_play_period; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = is_connect_requested; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = is_heart_sent; (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&userseq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int32_t) > nSize) { return false; }
		int32_t nickname_length = 0; std::memcpy(&nickname_length, *_buf_, sizeof(int32_t)); (*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		nickname.assign((char*)*_buf_, nickname_length); (*_buf_) += nickname_length; nSize -= nickname_length;
		if(sizeof(int32_t) > nSize) { return false; }
		int32_t profile_url_length = 0; std::memcpy(&profile_url_length, *_buf_, sizeof(int32_t)); (*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		profile_url.assign((char*)*_buf_, profile_url_length); (*_buf_) += profile_url_length; nSize -= profile_url_length;
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&no_play_period, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&is_connect_requested, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&is_heart_sent, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //iGameFriendInfo
struct iGameFriendInfo_Serializer {
	static bool Store(char** _buf_, const iGameFriendInfo& obj) { return obj.Store(_buf_); }
	static bool Load(iGameFriendInfo& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const iGameFriendInfo& obj) { return obj.Size(); }
};
struct iRealTimeFriendInfo {
	uint32_t	userseq;
	uint32_t	score;
	uint16_t	is_connected;
	uint16_t	buff_state;
	uint16_t	heart_blocked;
	uint16_t	invite_blocked;
	uint16_t	profile_opend;
	uint16_t	gender;
	uint16_t	gender_open;
	std::string	birthday;
	uint16_t	birth_open;
	uint16_t	server_id;
	uint16_t	channel_id;
	uint16_t	gold;
	uint16_t	silver;
	uint16_t	bronze;
	iRealTimeFriendInfo()	{
		userseq = 0;
		score = 0;
		is_connected = 0;
		buff_state = 0;
		heart_blocked = 0;
		invite_blocked = 0;
		profile_opend = 0;
		gender = 0;
		gender_open = 0;
		birth_open = 0;
		server_id = 0;
		channel_id = 0;
		gold = 0;
		silver = 0;
		bronze = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(int32_t); nSize += birthday.length();
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = userseq; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = score; (*_buf_) += sizeof(uint32_t);
		(*(uint16_t*)(*_buf_)) = is_connected; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = buff_state; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = heart_blocked; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = invite_blocked; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = profile_opend; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = gender; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = gender_open; (*_buf_) += sizeof(uint16_t);
		(*(int32_t*)(*_buf_)) = (int32_t)birthday.length(); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, birthday.c_str(), birthday.length());
		(*_buf_) += birthday.length();
		(*(uint16_t*)(*_buf_)) = birth_open; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = server_id; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = channel_id; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = gold; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = silver; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = bronze; (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&userseq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&score, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&is_connected, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&buff_state, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&heart_blocked, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&invite_blocked, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&profile_opend, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&gender, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&gender_open, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(int32_t) > nSize) { return false; }
		int32_t birthday_length = 0; std::memcpy(&birthday_length, *_buf_, sizeof(int32_t)); (*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		birthday.assign((char*)*_buf_, birthday_length); (*_buf_) += birthday_length; nSize -= birthday_length;
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&birth_open, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&server_id, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&channel_id, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&gold, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&silver, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&bronze, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //iRealTimeFriendInfo
struct iRealTimeFriendInfo_Serializer {
	static bool Store(char** _buf_, const iRealTimeFriendInfo& obj) { return obj.Store(_buf_); }
	static bool Load(iRealTimeFriendInfo& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const iRealTimeFriendInfo& obj) { return obj.Size(); }
};
struct iNewsInfo {
	uint64_t	news_seq;
	uint32_t	user_seq;
	uint16_t	news_type;
	uint32_t	heart_count;
	std::string	nickname;
	std::string	profile_url;
	iNewsInfo()	{
		news_seq = 0;
		user_seq = 0;
		news_type = 0;
		heart_count = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint64_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(int32_t); nSize += nickname.length();
		nSize += sizeof(int32_t); nSize += profile_url.length();
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint64_t*)(*_buf_)) = news_seq; (*_buf_) += sizeof(uint64_t);
		(*(uint32_t*)(*_buf_)) = user_seq; (*_buf_) += sizeof(uint32_t);
		(*(uint16_t*)(*_buf_)) = news_type; (*_buf_) += sizeof(uint16_t);
		(*(uint32_t*)(*_buf_)) = heart_count; (*_buf_) += sizeof(uint32_t);
		(*(int32_t*)(*_buf_)) = (int32_t)nickname.length(); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, nickname.c_str(), nickname.length());
		(*_buf_) += nickname.length();
		(*(int32_t*)(*_buf_)) = (int32_t)profile_url.length(); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, profile_url.c_str(), profile_url.length());
		(*_buf_) += profile_url.length();
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint64_t) > nSize) { return false; }	std::memcpy(&news_seq, *_buf_, sizeof(uint64_t));	(*_buf_) += sizeof(uint64_t); nSize -= sizeof(uint64_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&news_type, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&heart_count, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int32_t) > nSize) { return false; }
		int32_t nickname_length = 0; std::memcpy(&nickname_length, *_buf_, sizeof(int32_t)); (*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		nickname.assign((char*)*_buf_, nickname_length); (*_buf_) += nickname_length; nSize -= nickname_length;
		if(sizeof(int32_t) > nSize) { return false; }
		int32_t profile_url_length = 0; std::memcpy(&profile_url_length, *_buf_, sizeof(int32_t)); (*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		profile_url.assign((char*)*_buf_, profile_url_length); (*_buf_) += profile_url_length; nSize -= profile_url_length;
		return true;
	}
}; //iNewsInfo
struct iNewsInfo_Serializer {
	static bool Store(char** _buf_, const iNewsInfo& obj) { return obj.Store(_buf_); }
	static bool Load(iNewsInfo& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const iNewsInfo& obj) { return obj.Size(); }
};
struct iPlayable {
	uint32_t	gid;
	uint16_t	class_type;
	uint16_t	is_playable;
	iPlayable()	{
		gid = 0;
		class_type = 0;
		is_playable = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = gid; (*_buf_) += sizeof(uint32_t);
		(*(uint16_t*)(*_buf_)) = class_type; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = is_playable; (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&gid, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&class_type, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&is_playable, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //iPlayable
struct iPlayable_Serializer {
	static bool Store(char** _buf_, const iPlayable& obj) { return obj.Store(_buf_); }
	static bool Load(iPlayable& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const iPlayable& obj) { return obj.Size(); }
};
struct iMessage {
	uint16_t	type;
	std::string	msg;
	iMessage()	{
		type = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint16_t);
		nSize += sizeof(int32_t); nSize += msg.length();
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint16_t*)(*_buf_)) = type; (*_buf_) += sizeof(uint16_t);
		(*(int32_t*)(*_buf_)) = (int32_t)msg.length(); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, msg.c_str(), msg.length());
		(*_buf_) += msg.length();
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&type, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(int32_t) > nSize) { return false; }
		int32_t msg_length = 0; std::memcpy(&msg_length, *_buf_, sizeof(int32_t)); (*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		msg.assign((char*)*_buf_, msg_length); (*_buf_) += msg_length; nSize -= msg_length;
		return true;
	}
}; //iMessage
struct iMessage_Serializer {
	static bool Store(char** _buf_, const iMessage& obj) { return obj.Store(_buf_); }
	static bool Load(iMessage& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const iMessage& obj) { return obj.Size(); }
};
struct iScore {
	uint32_t	gid;
	uint32_t	score;
	iScore()	{
		gid = 0;
		score = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = gid; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = score; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&gid, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&score, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //iScore
struct iScore_Serializer {
	static bool Store(char** _buf_, const iScore& obj) { return obj.Store(_buf_); }
	static bool Load(iScore& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const iScore& obj) { return obj.Size(); }
};
struct FriendsOpenAck {
	enum { MSG_ID = 1 }; 
	FriendsOpenAck()	{
	}
	int32_t Size() const {
		int32_t nSize = 0;
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		return true;
	}
}; //FriendsOpenAck
struct FriendsOpenAck_Serializer {
	static bool Store(char** _buf_, const FriendsOpenAck& obj) { return obj.Store(_buf_); }
	static bool Load(FriendsOpenAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const FriendsOpenAck& obj) { return obj.Size(); }
};
struct FriendsCloseAck {
	enum { MSG_ID = 2 }; 
	FriendsCloseAck()	{
	}
	int32_t Size() const {
		int32_t nSize = 0;
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		return true;
	}
}; //FriendsCloseAck
struct FriendsCloseAck_Serializer {
	static bool Store(char** _buf_, const FriendsCloseAck& obj) { return obj.Store(_buf_); }
	static bool Load(FriendsCloseAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const FriendsCloseAck& obj) { return obj.Size(); }
};
struct SocialFriendsSyn {
	enum { MSG_ID = 5001 }; 
	uint32_t	seq;
	std::vector<uint32_t >	userseq;
	SocialFriendsSyn()	{
		seq = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int32_t);
		for(std::vector<uint32_t >::const_iterator userseq_itr = userseq.begin(); userseq_itr != userseq.end(); userseq_itr++)	{
			const uint32_t& userseq_elmt = *userseq_itr;
			nSize += sizeof(uint32_t);
		}
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int32_t*)(*_buf_)) = (int32_t)userseq.size(); (*_buf_) += sizeof(int32_t);
		for(std::vector<uint32_t >::const_iterator userseq_itr = userseq.begin(); userseq_itr != userseq.end(); userseq_itr++)	{
			const uint32_t& userseq_elmt = *userseq_itr;
			(*(uint32_t*)(*_buf_)) = userseq_elmt; (*_buf_) += sizeof(uint32_t);
		}
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int32_t) > nSize) { return false; }
		int32_t userseq_length = 0; std::memcpy(&userseq_length, *_buf_, sizeof(int32_t)); (*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		for(int32_t i=0; i<userseq_length; i++) {
			uint32_t userseq_val;
			if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&userseq_val, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
			userseq.push_back(userseq_val);
		}
		return true;
	}
}; //SocialFriendsSyn
struct SocialFriendsSyn_Serializer {
	static bool Store(char** _buf_, const SocialFriendsSyn& obj) { return obj.Store(_buf_); }
	static bool Load(SocialFriendsSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const SocialFriendsSyn& obj) { return obj.Size(); }
};
struct SocialFriendsAck {
	enum { MSG_ID = 5002 }; 
	uint32_t	seq;
	int16_t	result;
	std::vector<iSocialFriendInfo >	array_Friends;
	SocialFriendsAck()	{
		seq = 0;
		result = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(int32_t);
		for(std::vector<iSocialFriendInfo >::const_iterator array_Friends_itr = array_Friends.begin(); array_Friends_itr != array_Friends.end(); array_Friends_itr++)	{
			const iSocialFriendInfo& array_Friends_elmt = *array_Friends_itr;
			nSize += iSocialFriendInfo_Serializer::Size(array_Friends_elmt);
		}
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		(*(int32_t*)(*_buf_)) = (int32_t)array_Friends.size(); (*_buf_) += sizeof(int32_t);
		for(std::vector<iSocialFriendInfo >::const_iterator array_Friends_itr = array_Friends.begin(); array_Friends_itr != array_Friends.end(); array_Friends_itr++)	{
			const iSocialFriendInfo& array_Friends_elmt = *array_Friends_itr;
			if(false == iSocialFriendInfo_Serializer::Store(_buf_, array_Friends_elmt)) { return false; }
		}
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(int32_t) > nSize) { return false; }
		int32_t array_Friends_length = 0; std::memcpy(&array_Friends_length, *_buf_, sizeof(int32_t)); (*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		for(int32_t i=0; i<array_Friends_length; i++) {
			iSocialFriendInfo array_Friends_val;
			if(false == iSocialFriendInfo_Serializer::Load(array_Friends_val, _buf_, nSize)) { return false; }
			array_Friends.push_back(array_Friends_val);
		}
		return true;
	}
}; //SocialFriendsAck
struct SocialFriendsAck_Serializer {
	static bool Store(char** _buf_, const SocialFriendsAck& obj) { return obj.Store(_buf_); }
	static bool Load(SocialFriendsAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const SocialFriendsAck& obj) { return obj.Size(); }
};
struct GameFriendsSyn {
	enum { MSG_ID = 5003 }; 
	uint32_t	seq;
	std::vector<uint32_t >	userseq;
	GameFriendsSyn()	{
		seq = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int32_t);
		for(std::vector<uint32_t >::const_iterator userseq_itr = userseq.begin(); userseq_itr != userseq.end(); userseq_itr++)	{
			const uint32_t& userseq_elmt = *userseq_itr;
			nSize += sizeof(uint32_t);
		}
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int32_t*)(*_buf_)) = (int32_t)userseq.size(); (*_buf_) += sizeof(int32_t);
		for(std::vector<uint32_t >::const_iterator userseq_itr = userseq.begin(); userseq_itr != userseq.end(); userseq_itr++)	{
			const uint32_t& userseq_elmt = *userseq_itr;
			(*(uint32_t*)(*_buf_)) = userseq_elmt; (*_buf_) += sizeof(uint32_t);
		}
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int32_t) > nSize) { return false; }
		int32_t userseq_length = 0; std::memcpy(&userseq_length, *_buf_, sizeof(int32_t)); (*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		for(int32_t i=0; i<userseq_length; i++) {
			uint32_t userseq_val;
			if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&userseq_val, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
			userseq.push_back(userseq_val);
		}
		return true;
	}
}; //GameFriendsSyn
struct GameFriendsSyn_Serializer {
	static bool Store(char** _buf_, const GameFriendsSyn& obj) { return obj.Store(_buf_); }
	static bool Load(GameFriendsSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const GameFriendsSyn& obj) { return obj.Size(); }
};
struct GameFriendsAck {
	enum { MSG_ID = 5004 }; 
	uint32_t	seq;
	int16_t	result;
	std::vector<iGameFriendInfo >	array_Friends;
	GameFriendsAck()	{
		seq = 0;
		result = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(int32_t);
		for(std::vector<iGameFriendInfo >::const_iterator array_Friends_itr = array_Friends.begin(); array_Friends_itr != array_Friends.end(); array_Friends_itr++)	{
			const iGameFriendInfo& array_Friends_elmt = *array_Friends_itr;
			nSize += iGameFriendInfo_Serializer::Size(array_Friends_elmt);
		}
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		(*(int32_t*)(*_buf_)) = (int32_t)array_Friends.size(); (*_buf_) += sizeof(int32_t);
		for(std::vector<iGameFriendInfo >::const_iterator array_Friends_itr = array_Friends.begin(); array_Friends_itr != array_Friends.end(); array_Friends_itr++)	{
			const iGameFriendInfo& array_Friends_elmt = *array_Friends_itr;
			if(false == iGameFriendInfo_Serializer::Store(_buf_, array_Friends_elmt)) { return false; }
		}
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(int32_t) > nSize) { return false; }
		int32_t array_Friends_length = 0; std::memcpy(&array_Friends_length, *_buf_, sizeof(int32_t)); (*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		for(int32_t i=0; i<array_Friends_length; i++) {
			iGameFriendInfo array_Friends_val;
			if(false == iGameFriendInfo_Serializer::Load(array_Friends_val, _buf_, nSize)) { return false; }
			array_Friends.push_back(array_Friends_val);
		}
		return true;
	}
}; //GameFriendsAck
struct GameFriendsAck_Serializer {
	static bool Store(char** _buf_, const GameFriendsAck& obj) { return obj.Store(_buf_); }
	static bool Load(GameFriendsAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const GameFriendsAck& obj) { return obj.Size(); }
};
struct InviteNoAppSyn {
	enum { MSG_ID = 5007 }; 
	uint32_t	seq;
	std::string	user_id;
	uint32_t	heart_count_max;
	uint16_t	send_heart_count;
	uint16_t	recv_heart_count;
	uint16_t	msg_type;
	InviteNoAppSyn()	{
		seq = 0;
		heart_count_max = 0;
		send_heart_count = 0;
		recv_heart_count = 0;
		msg_type = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int32_t); nSize += user_id.length();
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int32_t*)(*_buf_)) = (int32_t)user_id.length(); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, user_id.c_str(), user_id.length());
		(*_buf_) += user_id.length();
		(*(uint32_t*)(*_buf_)) = heart_count_max; (*_buf_) += sizeof(uint32_t);
		(*(uint16_t*)(*_buf_)) = send_heart_count; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = recv_heart_count; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = msg_type; (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int32_t) > nSize) { return false; }
		int32_t user_id_length = 0; std::memcpy(&user_id_length, *_buf_, sizeof(int32_t)); (*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		user_id.assign((char*)*_buf_, user_id_length); (*_buf_) += user_id_length; nSize -= user_id_length;
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&heart_count_max, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&send_heart_count, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&recv_heart_count, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&msg_type, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //InviteNoAppSyn
struct InviteNoAppSyn_Serializer {
	static bool Store(char** _buf_, const InviteNoAppSyn& obj) { return obj.Store(_buf_); }
	static bool Load(InviteNoAppSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const InviteNoAppSyn& obj) { return obj.Size(); }
};
struct InviteNoAppAck {
	enum { MSG_ID = 5008 }; 
	uint32_t	seq;
	int16_t	result;
	uint32_t	heart_count;
	uint16_t	invite_count;
	InviteNoAppAck()	{
		seq = 0;
		result = 0;
		heart_count = 0;
		invite_count = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		(*(uint32_t*)(*_buf_)) = heart_count; (*_buf_) += sizeof(uint32_t);
		(*(uint16_t*)(*_buf_)) = invite_count; (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&heart_count, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&invite_count, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //InviteNoAppAck
struct InviteNoAppAck_Serializer {
	static bool Store(char** _buf_, const InviteNoAppAck& obj) { return obj.Store(_buf_); }
	static bool Load(InviteNoAppAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const InviteNoAppAck& obj) { return obj.Size(); }
};
struct NewsInfoSyn {
	enum { MSG_ID = 5009 }; 
	uint32_t	seq;
	uint16_t	page_num;
	NewsInfoSyn()	{
		seq = 0;
		page_num = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint16_t*)(*_buf_)) = page_num; (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&page_num, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //NewsInfoSyn
struct NewsInfoSyn_Serializer {
	static bool Store(char** _buf_, const NewsInfoSyn& obj) { return obj.Store(_buf_); }
	static bool Load(NewsInfoSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const NewsInfoSyn& obj) { return obj.Size(); }
};
struct NewsInfoAck {
	enum { MSG_ID = 5010 }; 
	uint32_t	seq;
	int16_t	result;
	uint16_t	isLastPage;
	std::vector<iNewsInfo >	array_News;
	NewsInfoAck()	{
		seq = 0;
		result = 0;
		isLastPage = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(int32_t);
		for(std::vector<iNewsInfo >::const_iterator array_News_itr = array_News.begin(); array_News_itr != array_News.end(); array_News_itr++)	{
			const iNewsInfo& array_News_elmt = *array_News_itr;
			nSize += iNewsInfo_Serializer::Size(array_News_elmt);
		}
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		(*(uint16_t*)(*_buf_)) = isLastPage; (*_buf_) += sizeof(uint16_t);
		(*(int32_t*)(*_buf_)) = (int32_t)array_News.size(); (*_buf_) += sizeof(int32_t);
		for(std::vector<iNewsInfo >::const_iterator array_News_itr = array_News.begin(); array_News_itr != array_News.end(); array_News_itr++)	{
			const iNewsInfo& array_News_elmt = *array_News_itr;
			if(false == iNewsInfo_Serializer::Store(_buf_, array_News_elmt)) { return false; }
		}
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&isLastPage, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(int32_t) > nSize) { return false; }
		int32_t array_News_length = 0; std::memcpy(&array_News_length, *_buf_, sizeof(int32_t)); (*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		for(int32_t i=0; i<array_News_length; i++) {
			iNewsInfo array_News_val;
			if(false == iNewsInfo_Serializer::Load(array_News_val, _buf_, nSize)) { return false; }
			array_News.push_back(array_News_val);
		}
		return true;
	}
}; //NewsInfoAck
struct NewsInfoAck_Serializer {
	static bool Store(char** _buf_, const NewsInfoAck& obj) { return obj.Store(_buf_); }
	static bool Load(NewsInfoAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const NewsInfoAck& obj) { return obj.Size(); }
};
struct SimpleFriendsSyn {
	enum { MSG_ID = 5011 }; 
	uint32_t	seq;
	uint16_t	is_medal;
	std::vector<uint32_t >	user_seq;
	SimpleFriendsSyn()	{
		seq = 0;
		is_medal = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(int32_t);
		for(std::vector<uint32_t >::const_iterator user_seq_itr = user_seq.begin(); user_seq_itr != user_seq.end(); user_seq_itr++)	{
			const uint32_t& user_seq_elmt = *user_seq_itr;
			nSize += sizeof(uint32_t);
		}
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint16_t*)(*_buf_)) = is_medal; (*_buf_) += sizeof(uint16_t);
		(*(int32_t*)(*_buf_)) = (int32_t)user_seq.size(); (*_buf_) += sizeof(int32_t);
		for(std::vector<uint32_t >::const_iterator user_seq_itr = user_seq.begin(); user_seq_itr != user_seq.end(); user_seq_itr++)	{
			const uint32_t& user_seq_elmt = *user_seq_itr;
			(*(uint32_t*)(*_buf_)) = user_seq_elmt; (*_buf_) += sizeof(uint32_t);
		}
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&is_medal, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(int32_t) > nSize) { return false; }
		int32_t user_seq_length = 0; std::memcpy(&user_seq_length, *_buf_, sizeof(int32_t)); (*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		for(int32_t i=0; i<user_seq_length; i++) {
			uint32_t user_seq_val;
			if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&user_seq_val, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
			user_seq.push_back(user_seq_val);
		}
		return true;
	}
}; //SimpleFriendsSyn
struct SimpleFriendsSyn_Serializer {
	static bool Store(char** _buf_, const SimpleFriendsSyn& obj) { return obj.Store(_buf_); }
	static bool Load(SimpleFriendsSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const SimpleFriendsSyn& obj) { return obj.Size(); }
};
struct SimpleFriendsAck {
	enum { MSG_ID = 5012 }; 
	uint32_t	seq;
	int16_t	result;
	uint16_t	is_medal;
	std::vector<iRealTimeFriendInfo >	array_Friends;
	SimpleFriendsAck()	{
		seq = 0;
		result = 0;
		is_medal = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(int32_t);
		for(std::vector<iRealTimeFriendInfo >::const_iterator array_Friends_itr = array_Friends.begin(); array_Friends_itr != array_Friends.end(); array_Friends_itr++)	{
			const iRealTimeFriendInfo& array_Friends_elmt = *array_Friends_itr;
			nSize += iRealTimeFriendInfo_Serializer::Size(array_Friends_elmt);
		}
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		(*(uint16_t*)(*_buf_)) = is_medal; (*_buf_) += sizeof(uint16_t);
		(*(int32_t*)(*_buf_)) = (int32_t)array_Friends.size(); (*_buf_) += sizeof(int32_t);
		for(std::vector<iRealTimeFriendInfo >::const_iterator array_Friends_itr = array_Friends.begin(); array_Friends_itr != array_Friends.end(); array_Friends_itr++)	{
			const iRealTimeFriendInfo& array_Friends_elmt = *array_Friends_itr;
			if(false == iRealTimeFriendInfo_Serializer::Store(_buf_, array_Friends_elmt)) { return false; }
		}
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&is_medal, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(int32_t) > nSize) { return false; }
		int32_t array_Friends_length = 0; std::memcpy(&array_Friends_length, *_buf_, sizeof(int32_t)); (*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		for(int32_t i=0; i<array_Friends_length; i++) {
			iRealTimeFriendInfo array_Friends_val;
			if(false == iRealTimeFriendInfo_Serializer::Load(array_Friends_val, _buf_, nSize)) { return false; }
			array_Friends.push_back(array_Friends_val);
		}
		return true;
	}
}; //SimpleFriendsAck
struct SimpleFriendsAck_Serializer {
	static bool Store(char** _buf_, const SimpleFriendsAck& obj) { return obj.Store(_buf_); }
	static bool Load(SimpleFriendsAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const SimpleFriendsAck& obj) { return obj.Size(); }
};
struct MainListSyn {
	enum { MSG_ID = 5015 }; 
	uint32_t	seq;
	MainListSyn()	{
		seq = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //MainListSyn
struct MainListSyn_Serializer {
	static bool Store(char** _buf_, const MainListSyn& obj) { return obj.Store(_buf_); }
	static bool Load(MainListSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const MainListSyn& obj) { return obj.Size(); }
};
struct MainListAck {
	enum { MSG_ID = 5016 }; 
	uint32_t	seq;
	int16_t	result;
	uint16_t	heart_count;
	int32_t	my_ranking;
	uint32_t	last_week_friend_count;
	MainListAck()	{
		seq = 0;
		result = 0;
		heart_count = 0;
		my_ranking = 0;
		last_week_friend_count = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(int32_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		(*(uint16_t*)(*_buf_)) = heart_count; (*_buf_) += sizeof(uint16_t);
		(*(int32_t*)(*_buf_)) = my_ranking; (*_buf_) += sizeof(int32_t);
		(*(uint32_t*)(*_buf_)) = last_week_friend_count; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&heart_count, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(int32_t) > nSize) { return false; }	std::memcpy(&my_ranking, *_buf_, sizeof(int32_t));	(*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&last_week_friend_count, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //MainListAck
struct MainListAck_Serializer {
	static bool Store(char** _buf_, const MainListAck& obj) { return obj.Store(_buf_); }
	static bool Load(MainListAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const MainListAck& obj) { return obj.Size(); }
};
struct UpdateProfileSyn {
	enum { MSG_ID = 5019 }; 
	uint32_t	seq;
	uint16_t	gender;
	uint16_t	is_gender_open;
	std::string	birthday;
	uint16_t	is_birthday_open;
	uint16_t	is_profile_open;
	UpdateProfileSyn()	{
		seq = 0;
		gender = 0;
		is_gender_open = 0;
		is_birthday_open = 0;
		is_profile_open = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(int32_t); nSize += birthday.length();
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint16_t*)(*_buf_)) = gender; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = is_gender_open; (*_buf_) += sizeof(uint16_t);
		(*(int32_t*)(*_buf_)) = (int32_t)birthday.length(); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, birthday.c_str(), birthday.length());
		(*_buf_) += birthday.length();
		(*(uint16_t*)(*_buf_)) = is_birthday_open; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = is_profile_open; (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&gender, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&is_gender_open, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(int32_t) > nSize) { return false; }
		int32_t birthday_length = 0; std::memcpy(&birthday_length, *_buf_, sizeof(int32_t)); (*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		birthday.assign((char*)*_buf_, birthday_length); (*_buf_) += birthday_length; nSize -= birthday_length;
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&is_birthday_open, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&is_profile_open, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //UpdateProfileSyn
struct UpdateProfileSyn_Serializer {
	static bool Store(char** _buf_, const UpdateProfileSyn& obj) { return obj.Store(_buf_); }
	static bool Load(UpdateProfileSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const UpdateProfileSyn& obj) { return obj.Size(); }
};
struct UpdateProfileAck {
	enum { MSG_ID = 5020 }; 
	uint32_t	seq;
	int16_t	result;
	uint16_t	gender;
	uint16_t	is_gender_open;
	std::string	birthday;
	uint16_t	is_birthday_open;
	uint16_t	is_profile_open;
	UpdateProfileAck()	{
		seq = 0;
		result = 0;
		gender = 0;
		is_gender_open = 0;
		is_birthday_open = 0;
		is_profile_open = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(int32_t); nSize += birthday.length();
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		(*(uint16_t*)(*_buf_)) = gender; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = is_gender_open; (*_buf_) += sizeof(uint16_t);
		(*(int32_t*)(*_buf_)) = (int32_t)birthday.length(); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, birthday.c_str(), birthday.length());
		(*_buf_) += birthday.length();
		(*(uint16_t*)(*_buf_)) = is_birthday_open; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = is_profile_open; (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&gender, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&is_gender_open, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(int32_t) > nSize) { return false; }
		int32_t birthday_length = 0; std::memcpy(&birthday_length, *_buf_, sizeof(int32_t)); (*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		birthday.assign((char*)*_buf_, birthday_length); (*_buf_) += birthday_length; nSize -= birthday_length;
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&is_birthday_open, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&is_profile_open, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //UpdateProfileAck
struct UpdateProfileAck_Serializer {
	static bool Store(char** _buf_, const UpdateProfileAck& obj) { return obj.Store(_buf_); }
	static bool Load(UpdateProfileAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const UpdateProfileAck& obj) { return obj.Size(); }
};
struct UpdateStatusSyn {
	enum { MSG_ID = 5025 }; 
	uint32_t	seq;
	uint16_t	is_heart_block;
	uint16_t	is_invite_block;
	UpdateStatusSyn()	{
		seq = 0;
		is_heart_block = 0;
		is_invite_block = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint16_t*)(*_buf_)) = is_heart_block; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = is_invite_block; (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&is_heart_block, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&is_invite_block, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //UpdateStatusSyn
struct UpdateStatusSyn_Serializer {
	static bool Store(char** _buf_, const UpdateStatusSyn& obj) { return obj.Store(_buf_); }
	static bool Load(UpdateStatusSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const UpdateStatusSyn& obj) { return obj.Size(); }
};
struct UpdateStatusAck {
	enum { MSG_ID = 5026 }; 
	uint32_t	seq;
	int16_t	result;
	uint16_t	is_heart_block;
	uint16_t	is_invite_block;
	UpdateStatusAck()	{
		seq = 0;
		result = 0;
		is_heart_block = 0;
		is_invite_block = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		(*(uint16_t*)(*_buf_)) = is_heart_block; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = is_invite_block; (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&is_heart_block, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&is_invite_block, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //UpdateStatusAck
struct UpdateStatusAck_Serializer {
	static bool Store(char** _buf_, const UpdateStatusAck& obj) { return obj.Store(_buf_); }
	static bool Load(UpdateStatusAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const UpdateStatusAck& obj) { return obj.Size(); }
};
struct SendHeartSyn {
	enum { MSG_ID = 5027 }; 
	uint32_t	seq;
	uint32_t	gid;
	uint32_t	heart_count;
	uint16_t	is_push;
	uint32_t	heart_count_max;
	uint16_t	send_heart_count;
	uint16_t	recv_heart_count;
	uint16_t	msg_type;
	SendHeartSyn()	{
		seq = 0;
		gid = 0;
		heart_count = 0;
		is_push = 0;
		heart_count_max = 0;
		send_heart_count = 0;
		recv_heart_count = 0;
		msg_type = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = gid; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = heart_count; (*_buf_) += sizeof(uint32_t);
		(*(uint16_t*)(*_buf_)) = is_push; (*_buf_) += sizeof(uint16_t);
		(*(uint32_t*)(*_buf_)) = heart_count_max; (*_buf_) += sizeof(uint32_t);
		(*(uint16_t*)(*_buf_)) = send_heart_count; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = recv_heart_count; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = msg_type; (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&gid, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&heart_count, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&is_push, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&heart_count_max, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&send_heart_count, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&recv_heart_count, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&msg_type, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //SendHeartSyn
struct SendHeartSyn_Serializer {
	static bool Store(char** _buf_, const SendHeartSyn& obj) { return obj.Store(_buf_); }
	static bool Load(SendHeartSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const SendHeartSyn& obj) { return obj.Size(); }
};
struct SendHeartAck {
	enum { MSG_ID = 5028 }; 
	uint32_t	seq;
	int16_t	result;
	uint32_t	heart_count;
	SendHeartAck()	{
		seq = 0;
		result = 0;
		heart_count = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		(*(uint32_t*)(*_buf_)) = heart_count; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&heart_count, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //SendHeartAck
struct SendHeartAck_Serializer {
	static bool Store(char** _buf_, const SendHeartAck& obj) { return obj.Store(_buf_); }
	static bool Load(SendHeartAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const SendHeartAck& obj) { return obj.Size(); }
};
struct RecommendSyn {
	enum { MSG_ID = 5029 }; 
	uint32_t	seq;
	uint32_t	gid;
	RecommendSyn()	{
		seq = 0;
		gid = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = gid; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&gid, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //RecommendSyn
struct RecommendSyn_Serializer {
	static bool Store(char** _buf_, const RecommendSyn& obj) { return obj.Store(_buf_); }
	static bool Load(RecommendSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const RecommendSyn& obj) { return obj.Size(); }
};
struct RecommendAck {
	enum { MSG_ID = 5030 }; 
	uint32_t	seq;
	int16_t	result;
	uint32_t	gid;
	RecommendAck()	{
		seq = 0;
		result = 0;
		gid = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		(*(uint32_t*)(*_buf_)) = gid; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&gid, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //RecommendAck
struct RecommendAck_Serializer {
	static bool Store(char** _buf_, const RecommendAck& obj) { return obj.Store(_buf_); }
	static bool Load(RecommendAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const RecommendAck& obj) { return obj.Size(); }
};
struct BoastSyn {
	enum { MSG_ID = 5033 }; 
	uint32_t	seq;
	uint32_t	gid;
	uint16_t	type;
	uint32_t	param;
	uint32_t	subparam;
	uint32_t	heart_count_max;
	uint16_t	send_heart_count;
	uint16_t	recv_heart_count;
	uint16_t	msg_type;
	BoastSyn()	{
		seq = 0;
		gid = 0;
		type = 0;
		param = 0;
		subparam = 0;
		heart_count_max = 0;
		send_heart_count = 0;
		recv_heart_count = 0;
		msg_type = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = gid; (*_buf_) += sizeof(uint32_t);
		(*(uint16_t*)(*_buf_)) = type; (*_buf_) += sizeof(uint16_t);
		(*(uint32_t*)(*_buf_)) = param; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = subparam; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = heart_count_max; (*_buf_) += sizeof(uint32_t);
		(*(uint16_t*)(*_buf_)) = send_heart_count; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = recv_heart_count; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = msg_type; (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&gid, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&type, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&param, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&subparam, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&heart_count_max, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&send_heart_count, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&recv_heart_count, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&msg_type, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //BoastSyn
struct BoastSyn_Serializer {
	static bool Store(char** _buf_, const BoastSyn& obj) { return obj.Store(_buf_); }
	static bool Load(BoastSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const BoastSyn& obj) { return obj.Size(); }
};
struct BoastAck {
	enum { MSG_ID = 5034 }; 
	uint32_t	seq;
	int16_t	result;
	uint32_t	heart_count;
	BoastAck()	{
		seq = 0;
		result = 0;
		heart_count = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		(*(uint32_t*)(*_buf_)) = heart_count; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&heart_count, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //BoastAck
struct BoastAck_Serializer {
	static bool Store(char** _buf_, const BoastAck& obj) { return obj.Store(_buf_); }
	static bool Load(BoastAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const BoastAck& obj) { return obj.Size(); }
};
struct UseBuffSyn {
	enum { MSG_ID = 5035 }; 
	uint32_t	seq;
	uint32_t	gid;
	uint32_t	buff_time;
	uint32_t	heart_count_max;
	uint16_t	send_heart_count;
	uint16_t	recv_heart_count;
	uint16_t	msg_type;
	UseBuffSyn()	{
		seq = 0;
		gid = 0;
		buff_time = 0;
		heart_count_max = 0;
		send_heart_count = 0;
		recv_heart_count = 0;
		msg_type = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = gid; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = buff_time; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = heart_count_max; (*_buf_) += sizeof(uint32_t);
		(*(uint16_t*)(*_buf_)) = send_heart_count; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = recv_heart_count; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = msg_type; (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&gid, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&buff_time, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&heart_count_max, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&send_heart_count, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&recv_heart_count, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&msg_type, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //UseBuffSyn
struct UseBuffSyn_Serializer {
	static bool Store(char** _buf_, const UseBuffSyn& obj) { return obj.Store(_buf_); }
	static bool Load(UseBuffSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const UseBuffSyn& obj) { return obj.Size(); }
};
struct UseBuffAck {
	enum { MSG_ID = 5036 }; 
	uint32_t	seq;
	int16_t	result;
	uint32_t	buff_time;
	uint32_t	heart_count;
	UseBuffAck()	{
		seq = 0;
		result = 0;
		buff_time = 0;
		heart_count = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		(*(uint32_t*)(*_buf_)) = buff_time; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = heart_count; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&buff_time, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&heart_count, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //UseBuffAck
struct UseBuffAck_Serializer {
	static bool Store(char** _buf_, const UseBuffAck& obj) { return obj.Store(_buf_); }
	static bool Load(UseBuffAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const UseBuffAck& obj) { return obj.Size(); }
};
struct GameFriendSyn {
	enum { MSG_ID = 5039 }; 
	uint32_t	seq;
	uint32_t	gid;
	uint32_t	heart_count_max;
	uint16_t	send_heart_count;
	uint16_t	recv_heart_count;
	uint16_t	msg_type;
	GameFriendSyn()	{
		seq = 0;
		gid = 0;
		heart_count_max = 0;
		send_heart_count = 0;
		recv_heart_count = 0;
		msg_type = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = gid; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = heart_count_max; (*_buf_) += sizeof(uint32_t);
		(*(uint16_t*)(*_buf_)) = send_heart_count; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = recv_heart_count; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = msg_type; (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&gid, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&heart_count_max, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&send_heart_count, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&recv_heart_count, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&msg_type, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //GameFriendSyn
struct GameFriendSyn_Serializer {
	static bool Store(char** _buf_, const GameFriendSyn& obj) { return obj.Store(_buf_); }
	static bool Load(GameFriendSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const GameFriendSyn& obj) { return obj.Size(); }
};
struct GameFriendAck {
	enum { MSG_ID = 5040 }; 
	uint32_t	seq;
	int16_t	result;
	uint32_t	heart_count;
	GameFriendAck()	{
		seq = 0;
		result = 0;
		heart_count = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		(*(uint32_t*)(*_buf_)) = heart_count; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&heart_count, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //GameFriendAck
struct GameFriendAck_Serializer {
	static bool Store(char** _buf_, const GameFriendAck& obj) { return obj.Store(_buf_); }
	static bool Load(GameFriendAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const GameFriendAck& obj) { return obj.Size(); }
};
struct ConfirmFriendSyn {
	enum { MSG_ID = 5041 }; 
	uint32_t	seq;
	uint64_t	news_seq;
	uint32_t	gid;
	uint16_t	is_accept;
	ConfirmFriendSyn()	{
		seq = 0;
		news_seq = 0;
		gid = 0;
		is_accept = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint64_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint64_t*)(*_buf_)) = news_seq; (*_buf_) += sizeof(uint64_t);
		(*(uint32_t*)(*_buf_)) = gid; (*_buf_) += sizeof(uint32_t);
		(*(uint16_t*)(*_buf_)) = is_accept; (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint64_t) > nSize) { return false; }	std::memcpy(&news_seq, *_buf_, sizeof(uint64_t));	(*_buf_) += sizeof(uint64_t); nSize -= sizeof(uint64_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&gid, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&is_accept, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //ConfirmFriendSyn
struct ConfirmFriendSyn_Serializer {
	static bool Store(char** _buf_, const ConfirmFriendSyn& obj) { return obj.Store(_buf_); }
	static bool Load(ConfirmFriendSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const ConfirmFriendSyn& obj) { return obj.Size(); }
};
struct ConfirmFriendAck {
	enum { MSG_ID = 5042 }; 
	uint32_t	seq;
	int16_t	result;
	uint64_t	news_seq;
	uint32_t	gid;
	uint16_t	is_accept;
	ConfirmFriendAck()	{
		seq = 0;
		result = 0;
		news_seq = 0;
		gid = 0;
		is_accept = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint64_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		(*(uint64_t*)(*_buf_)) = news_seq; (*_buf_) += sizeof(uint64_t);
		(*(uint32_t*)(*_buf_)) = gid; (*_buf_) += sizeof(uint32_t);
		(*(uint16_t*)(*_buf_)) = is_accept; (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint64_t) > nSize) { return false; }	std::memcpy(&news_seq, *_buf_, sizeof(uint64_t));	(*_buf_) += sizeof(uint64_t); nSize -= sizeof(uint64_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&gid, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&is_accept, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //ConfirmFriendAck
struct ConfirmFriendAck_Serializer {
	static bool Store(char** _buf_, const ConfirmFriendAck& obj) { return obj.Store(_buf_); }
	static bool Load(ConfirmFriendAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const ConfirmFriendAck& obj) { return obj.Size(); }
};
struct RequestConnectSyn {
	enum { MSG_ID = 5045 }; 
	uint32_t	seq;
	uint32_t	gid;
	uint32_t	heart_count_max;
	uint16_t	sleeping_user_checking_day_const;
	uint16_t	sleeping_user_invite_heart_point_reward;
	uint16_t	sleeping_user_invite_heart_point_reward_max;
	uint16_t	sleeping_user_be_invited_heart_point_reward;
	uint16_t	sleeping_user_be_invited_heart_point_reward_max;
	uint16_t	msg_type;
	RequestConnectSyn()	{
		seq = 0;
		gid = 0;
		heart_count_max = 0;
		sleeping_user_checking_day_const = 0;
		sleeping_user_invite_heart_point_reward = 0;
		sleeping_user_invite_heart_point_reward_max = 0;
		sleeping_user_be_invited_heart_point_reward = 0;
		sleeping_user_be_invited_heart_point_reward_max = 0;
		msg_type = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = gid; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = heart_count_max; (*_buf_) += sizeof(uint32_t);
		(*(uint16_t*)(*_buf_)) = sleeping_user_checking_day_const; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = sleeping_user_invite_heart_point_reward; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = sleeping_user_invite_heart_point_reward_max; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = sleeping_user_be_invited_heart_point_reward; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = sleeping_user_be_invited_heart_point_reward_max; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = msg_type; (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&gid, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&heart_count_max, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&sleeping_user_checking_day_const, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&sleeping_user_invite_heart_point_reward, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&sleeping_user_invite_heart_point_reward_max, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&sleeping_user_be_invited_heart_point_reward, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&sleeping_user_be_invited_heart_point_reward_max, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&msg_type, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //RequestConnectSyn
struct RequestConnectSyn_Serializer {
	static bool Store(char** _buf_, const RequestConnectSyn& obj) { return obj.Store(_buf_); }
	static bool Load(RequestConnectSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const RequestConnectSyn& obj) { return obj.Size(); }
};
struct RequestConnectAck {
	enum { MSG_ID = 5046 }; 
	uint32_t	seq;
	int16_t	result;
	uint32_t	heart_count;
	RequestConnectAck()	{
		seq = 0;
		result = 0;
		heart_count = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		(*(uint32_t*)(*_buf_)) = heart_count; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&heart_count, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //RequestConnectAck
struct RequestConnectAck_Serializer {
	static bool Store(char** _buf_, const RequestConnectAck& obj) { return obj.Store(_buf_); }
	static bool Load(RequestConnectAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const RequestConnectAck& obj) { return obj.Size(); }
};
struct ConfirmNewsSyn {
	enum { MSG_ID = 5047 }; 
	uint32_t	seq;
	uint16_t	type;
	uint64_t	news_seq;
	uint32_t	gid;
	uint32_t	heart_count_max;
	ConfirmNewsSyn()	{
		seq = 0;
		type = 0;
		news_seq = 0;
		gid = 0;
		heart_count_max = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint64_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint16_t*)(*_buf_)) = type; (*_buf_) += sizeof(uint16_t);
		(*(uint64_t*)(*_buf_)) = news_seq; (*_buf_) += sizeof(uint64_t);
		(*(uint32_t*)(*_buf_)) = gid; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = heart_count_max; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&type, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint64_t) > nSize) { return false; }	std::memcpy(&news_seq, *_buf_, sizeof(uint64_t));	(*_buf_) += sizeof(uint64_t); nSize -= sizeof(uint64_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&gid, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&heart_count_max, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //ConfirmNewsSyn
struct ConfirmNewsSyn_Serializer {
	static bool Store(char** _buf_, const ConfirmNewsSyn& obj) { return obj.Store(_buf_); }
	static bool Load(ConfirmNewsSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const ConfirmNewsSyn& obj) { return obj.Size(); }
};
struct ConfirmNewsAck {
	enum { MSG_ID = 5048 }; 
	uint32_t	seq;
	int16_t	result;
	uint32_t	heart_count;
	uint64_t	news_seq;
	ConfirmNewsAck()	{
		seq = 0;
		result = 0;
		heart_count = 0;
		news_seq = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint64_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		(*(uint32_t*)(*_buf_)) = heart_count; (*_buf_) += sizeof(uint32_t);
		(*(uint64_t*)(*_buf_)) = news_seq; (*_buf_) += sizeof(uint64_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&heart_count, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint64_t) > nSize) { return false; }	std::memcpy(&news_seq, *_buf_, sizeof(uint64_t));	(*_buf_) += sizeof(uint64_t); nSize -= sizeof(uint64_t);
		return true;
	}
}; //ConfirmNewsAck
struct ConfirmNewsAck_Serializer {
	static bool Store(char** _buf_, const ConfirmNewsAck& obj) { return obj.Store(_buf_); }
	static bool Load(ConfirmNewsAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const ConfirmNewsAck& obj) { return obj.Size(); }
};
struct DeleteFriendSyn {
	enum { MSG_ID = 5049 }; 
	uint32_t	seq;
	uint32_t	gid;
	DeleteFriendSyn()	{
		seq = 0;
		gid = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = gid; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&gid, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //DeleteFriendSyn
struct DeleteFriendSyn_Serializer {
	static bool Store(char** _buf_, const DeleteFriendSyn& obj) { return obj.Store(_buf_); }
	static bool Load(DeleteFriendSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const DeleteFriendSyn& obj) { return obj.Size(); }
};
struct DeleteFriendAck {
	enum { MSG_ID = 5050 }; 
	uint32_t	seq;
	int16_t	result;
	uint32_t	gid;
	DeleteFriendAck()	{
		seq = 0;
		result = 0;
		gid = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		(*(uint32_t*)(*_buf_)) = gid; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&gid, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //DeleteFriendAck
struct DeleteFriendAck_Serializer {
	static bool Store(char** _buf_, const DeleteFriendAck& obj) { return obj.Store(_buf_); }
	static bool Load(DeleteFriendAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const DeleteFriendAck& obj) { return obj.Size(); }
};
struct SocialUserSeqSyn {
	enum { MSG_ID = 5051 }; 
	uint32_t	seq;
	std::vector<uint64_t >	array_social_id;
	SocialUserSeqSyn()	{
		seq = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int32_t);
		for(std::vector<uint64_t >::const_iterator array_social_id_itr = array_social_id.begin(); array_social_id_itr != array_social_id.end(); array_social_id_itr++)	{
			const uint64_t& array_social_id_elmt = *array_social_id_itr;
			nSize += sizeof(uint64_t);
		}
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int32_t*)(*_buf_)) = (int32_t)array_social_id.size(); (*_buf_) += sizeof(int32_t);
		for(std::vector<uint64_t >::const_iterator array_social_id_itr = array_social_id.begin(); array_social_id_itr != array_social_id.end(); array_social_id_itr++)	{
			const uint64_t& array_social_id_elmt = *array_social_id_itr;
			(*(uint64_t*)(*_buf_)) = array_social_id_elmt; (*_buf_) += sizeof(uint64_t);
		}
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int32_t) > nSize) { return false; }
		int32_t array_social_id_length = 0; std::memcpy(&array_social_id_length, *_buf_, sizeof(int32_t)); (*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		for(int32_t i=0; i<array_social_id_length; i++) {
			uint64_t array_social_id_val;
			if(sizeof(uint64_t) > nSize) { return false; }	std::memcpy(&array_social_id_val, *_buf_, sizeof(uint64_t));	(*_buf_) += sizeof(uint64_t); nSize -= sizeof(uint64_t);
			array_social_id.push_back(array_social_id_val);
		}
		return true;
	}
}; //SocialUserSeqSyn
struct SocialUserSeqSyn_Serializer {
	static bool Store(char** _buf_, const SocialUserSeqSyn& obj) { return obj.Store(_buf_); }
	static bool Load(SocialUserSeqSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const SocialUserSeqSyn& obj) { return obj.Size(); }
};
struct SocialUserSeqAck {
	enum { MSG_ID = 5052 }; 
	uint32_t	seq;
	uint16_t	result;
	std::vector<iSocialUserSeqInfo >	array_social_userseq_info;
	SocialUserSeqAck()	{
		seq = 0;
		result = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(int32_t);
		for(std::vector<iSocialUserSeqInfo >::const_iterator array_social_userseq_info_itr = array_social_userseq_info.begin(); array_social_userseq_info_itr != array_social_userseq_info.end(); array_social_userseq_info_itr++)	{
			const iSocialUserSeqInfo& array_social_userseq_info_elmt = *array_social_userseq_info_itr;
			nSize += iSocialUserSeqInfo_Serializer::Size(array_social_userseq_info_elmt);
		}
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint16_t*)(*_buf_)) = result; (*_buf_) += sizeof(uint16_t);
		(*(int32_t*)(*_buf_)) = (int32_t)array_social_userseq_info.size(); (*_buf_) += sizeof(int32_t);
		for(std::vector<iSocialUserSeqInfo >::const_iterator array_social_userseq_info_itr = array_social_userseq_info.begin(); array_social_userseq_info_itr != array_social_userseq_info.end(); array_social_userseq_info_itr++)	{
			const iSocialUserSeqInfo& array_social_userseq_info_elmt = *array_social_userseq_info_itr;
			if(false == iSocialUserSeqInfo_Serializer::Store(_buf_, array_social_userseq_info_elmt)) { return false; }
		}
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(int32_t) > nSize) { return false; }
		int32_t array_social_userseq_info_length = 0; std::memcpy(&array_social_userseq_info_length, *_buf_, sizeof(int32_t)); (*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		for(int32_t i=0; i<array_social_userseq_info_length; i++) {
			iSocialUserSeqInfo array_social_userseq_info_val;
			if(false == iSocialUserSeqInfo_Serializer::Load(array_social_userseq_info_val, _buf_, nSize)) { return false; }
			array_social_userseq_info.push_back(array_social_userseq_info_val);
		}
		return true;
	}
}; //SocialUserSeqAck
struct SocialUserSeqAck_Serializer {
	static bool Store(char** _buf_, const SocialUserSeqAck& obj) { return obj.Store(_buf_); }
	static bool Load(SocialUserSeqAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const SocialUserSeqAck& obj) { return obj.Size(); }
};
struct GameUserSeqSyn {
	enum { MSG_ID = 5053 }; 
	uint32_t	seq;
	GameUserSeqSyn()	{
		seq = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //GameUserSeqSyn
struct GameUserSeqSyn_Serializer {
	static bool Store(char** _buf_, const GameUserSeqSyn& obj) { return obj.Store(_buf_); }
	static bool Load(GameUserSeqSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const GameUserSeqSyn& obj) { return obj.Size(); }
};
struct GameUserSeqAck {
	enum { MSG_ID = 5054 }; 
	uint32_t	seq;
	uint16_t	result;
	std::vector<iGameUserSeqInfo >	array_game_userseq_info;
	GameUserSeqAck()	{
		seq = 0;
		result = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(int32_t);
		for(std::vector<iGameUserSeqInfo >::const_iterator array_game_userseq_info_itr = array_game_userseq_info.begin(); array_game_userseq_info_itr != array_game_userseq_info.end(); array_game_userseq_info_itr++)	{
			const iGameUserSeqInfo& array_game_userseq_info_elmt = *array_game_userseq_info_itr;
			nSize += iGameUserSeqInfo_Serializer::Size(array_game_userseq_info_elmt);
		}
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint16_t*)(*_buf_)) = result; (*_buf_) += sizeof(uint16_t);
		(*(int32_t*)(*_buf_)) = (int32_t)array_game_userseq_info.size(); (*_buf_) += sizeof(int32_t);
		for(std::vector<iGameUserSeqInfo >::const_iterator array_game_userseq_info_itr = array_game_userseq_info.begin(); array_game_userseq_info_itr != array_game_userseq_info.end(); array_game_userseq_info_itr++)	{
			const iGameUserSeqInfo& array_game_userseq_info_elmt = *array_game_userseq_info_itr;
			if(false == iGameUserSeqInfo_Serializer::Store(_buf_, array_game_userseq_info_elmt)) { return false; }
		}
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(int32_t) > nSize) { return false; }
		int32_t array_game_userseq_info_length = 0; std::memcpy(&array_game_userseq_info_length, *_buf_, sizeof(int32_t)); (*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		for(int32_t i=0; i<array_game_userseq_info_length; i++) {
			iGameUserSeqInfo array_game_userseq_info_val;
			if(false == iGameUserSeqInfo_Serializer::Load(array_game_userseq_info_val, _buf_, nSize)) { return false; }
			array_game_userseq_info.push_back(array_game_userseq_info_val);
		}
		return true;
	}
}; //GameUserSeqAck
struct GameUserSeqAck_Serializer {
	static bool Store(char** _buf_, const GameUserSeqAck& obj) { return obj.Store(_buf_); }
	static bool Load(GameUserSeqAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const GameUserSeqAck& obj) { return obj.Size(); }
};
struct SocialMyInfoSyn {
	enum { MSG_ID = 5055 }; 
	uint32_t	seq;
	uint64_t	socialid;
	std::string	nickname;
	std::string	profile_url;
	SocialMyInfoSyn()	{
		seq = 0;
		socialid = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint64_t);
		nSize += sizeof(int32_t); nSize += nickname.length();
		nSize += sizeof(int32_t); nSize += profile_url.length();
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint64_t*)(*_buf_)) = socialid; (*_buf_) += sizeof(uint64_t);
		(*(int32_t*)(*_buf_)) = (int32_t)nickname.length(); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, nickname.c_str(), nickname.length());
		(*_buf_) += nickname.length();
		(*(int32_t*)(*_buf_)) = (int32_t)profile_url.length(); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, profile_url.c_str(), profile_url.length());
		(*_buf_) += profile_url.length();
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint64_t) > nSize) { return false; }	std::memcpy(&socialid, *_buf_, sizeof(uint64_t));	(*_buf_) += sizeof(uint64_t); nSize -= sizeof(uint64_t);
		if(sizeof(int32_t) > nSize) { return false; }
		int32_t nickname_length = 0; std::memcpy(&nickname_length, *_buf_, sizeof(int32_t)); (*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		nickname.assign((char*)*_buf_, nickname_length); (*_buf_) += nickname_length; nSize -= nickname_length;
		if(sizeof(int32_t) > nSize) { return false; }
		int32_t profile_url_length = 0; std::memcpy(&profile_url_length, *_buf_, sizeof(int32_t)); (*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		profile_url.assign((char*)*_buf_, profile_url_length); (*_buf_) += profile_url_length; nSize -= profile_url_length;
		return true;
	}
}; //SocialMyInfoSyn
struct SocialMyInfoSyn_Serializer {
	static bool Store(char** _buf_, const SocialMyInfoSyn& obj) { return obj.Store(_buf_); }
	static bool Load(SocialMyInfoSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const SocialMyInfoSyn& obj) { return obj.Size(); }
};
struct SocialMyInfoAck {
	enum { MSG_ID = 5056 }; 
	uint32_t	seq;
	int16_t	result;
	uint32_t	heart_count;
	uint16_t	heart_blocked;
	uint16_t	profile_opened;
	uint16_t	invite_block;
	uint16_t	gender;
	uint16_t	gender_open;
	std::string	birthday;
	uint16_t	birth_open;
	SocialMyInfoAck()	{
		seq = 0;
		result = 0;
		heart_count = 0;
		heart_blocked = 0;
		profile_opened = 0;
		invite_block = 0;
		gender = 0;
		gender_open = 0;
		birth_open = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(int32_t); nSize += birthday.length();
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		(*(uint32_t*)(*_buf_)) = heart_count; (*_buf_) += sizeof(uint32_t);
		(*(uint16_t*)(*_buf_)) = heart_blocked; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = profile_opened; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = invite_block; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = gender; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = gender_open; (*_buf_) += sizeof(uint16_t);
		(*(int32_t*)(*_buf_)) = (int32_t)birthday.length(); (*_buf_) += sizeof(int32_t);
		std::memcpy(*_buf_, birthday.c_str(), birthday.length());
		(*_buf_) += birthday.length();
		(*(uint16_t*)(*_buf_)) = birth_open; (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&heart_count, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&heart_blocked, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&profile_opened, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&invite_block, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&gender, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&gender_open, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(int32_t) > nSize) { return false; }
		int32_t birthday_length = 0; std::memcpy(&birthday_length, *_buf_, sizeof(int32_t)); (*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		birthday.assign((char*)*_buf_, birthday_length); (*_buf_) += birthday_length; nSize -= birthday_length;
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&birth_open, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //SocialMyInfoAck
struct SocialMyInfoAck_Serializer {
	static bool Store(char** _buf_, const SocialMyInfoAck& obj) { return obj.Store(_buf_); }
	static bool Load(SocialMyInfoAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const SocialMyInfoAck& obj) { return obj.Size(); }
};
struct FriendTypeModifySyn {
	enum { MSG_ID = 5057 }; 
	uint32_t	seq;
	uint64_t	socialid;
	uint32_t	gid;
	uint32_t	type;
	FriendTypeModifySyn()	{
		seq = 0;
		socialid = 0;
		gid = 0;
		type = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint64_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint64_t*)(*_buf_)) = socialid; (*_buf_) += sizeof(uint64_t);
		(*(uint32_t*)(*_buf_)) = gid; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = type; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint64_t) > nSize) { return false; }	std::memcpy(&socialid, *_buf_, sizeof(uint64_t));	(*_buf_) += sizeof(uint64_t); nSize -= sizeof(uint64_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&gid, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&type, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //FriendTypeModifySyn
struct FriendTypeModifySyn_Serializer {
	static bool Store(char** _buf_, const FriendTypeModifySyn& obj) { return obj.Store(_buf_); }
	static bool Load(FriendTypeModifySyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const FriendTypeModifySyn& obj) { return obj.Size(); }
};
struct FlushFRUserInfoSyn {
	enum { MSG_ID = 5058 }; 
	uint32_t	seq;
	FlushFRUserInfoSyn()	{
		seq = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //FlushFRUserInfoSyn
struct FlushFRUserInfoSyn_Serializer {
	static bool Store(char** _buf_, const FlushFRUserInfoSyn& obj) { return obj.Store(_buf_); }
	static bool Load(FlushFRUserInfoSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const FlushFRUserInfoSyn& obj) { return obj.Size(); }
};
struct FlushFRUserInfoAck {
	enum { MSG_ID = 5059 }; 
	uint32_t	seq;
	int16_t	result;
	FlushFRUserInfoAck()	{
		seq = 0;
		result = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		return true;
	}
}; //FlushFRUserInfoAck
struct FlushFRUserInfoAck_Serializer {
	static bool Store(char** _buf_, const FlushFRUserInfoAck& obj) { return obj.Store(_buf_); }
	static bool Load(FlushFRUserInfoAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const FlushFRUserInfoAck& obj) { return obj.Size(); }
};
struct RemoveFRUserSyn {
	enum { MSG_ID = 5062 }; 
	uint32_t	seq;
	RemoveFRUserSyn()	{
		seq = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //RemoveFRUserSyn
struct RemoveFRUserSyn_Serializer {
	static bool Store(char** _buf_, const RemoveFRUserSyn& obj) { return obj.Store(_buf_); }
	static bool Load(RemoveFRUserSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const RemoveFRUserSyn& obj) { return obj.Size(); }
};
struct RemoveFRUserAck {
	enum { MSG_ID = 5063 }; 
	uint32_t	seq;
	int16_t	result;
	RemoveFRUserAck()	{
		seq = 0;
		result = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		return true;
	}
}; //RemoveFRUserAck
struct RemoveFRUserAck_Serializer {
	static bool Store(char** _buf_, const RemoveFRUserAck& obj) { return obj.Store(_buf_); }
	static bool Load(RemoveFRUserAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const RemoveFRUserAck& obj) { return obj.Size(); }
};
struct NewsCountSyn {
	enum { MSG_ID = 5064 }; 
	uint32_t	seq;
	NewsCountSyn()	{
		seq = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //NewsCountSyn
struct NewsCountSyn_Serializer {
	static bool Store(char** _buf_, const NewsCountSyn& obj) { return obj.Store(_buf_); }
	static bool Load(NewsCountSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const NewsCountSyn& obj) { return obj.Size(); }
};
struct NewsCountAck {
	enum { MSG_ID = 5065 }; 
	uint32_t	seq;
	int16_t	result;
	uint16_t	news_count;
	NewsCountAck()	{
		seq = 0;
		result = 0;
		news_count = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		(*(uint16_t*)(*_buf_)) = news_count; (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&news_count, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //NewsCountAck
struct NewsCountAck_Serializer {
	static bool Store(char** _buf_, const NewsCountAck& obj) { return obj.Store(_buf_); }
	static bool Load(NewsCountAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const NewsCountAck& obj) { return obj.Size(); }
};
struct AllowFriendSyn {
	enum { MSG_ID = 5066 }; 
	uint32_t	seq;
	uint32_t	userseq;
	uint32_t	msgid;
	uint64_t	dummy;
	AllowFriendSyn()	{
		seq = 0;
		userseq = 0;
		msgid = 0;
		dummy = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint64_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = userseq; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = msgid; (*_buf_) += sizeof(uint32_t);
		(*(uint64_t*)(*_buf_)) = dummy; (*_buf_) += sizeof(uint64_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&userseq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&msgid, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint64_t) > nSize) { return false; }	std::memcpy(&dummy, *_buf_, sizeof(uint64_t));	(*_buf_) += sizeof(uint64_t); nSize -= sizeof(uint64_t);
		return true;
	}
}; //AllowFriendSyn
struct AllowFriendSyn_Serializer {
	static bool Store(char** _buf_, const AllowFriendSyn& obj) { return obj.Store(_buf_); }
	static bool Load(AllowFriendSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const AllowFriendSyn& obj) { return obj.Size(); }
};
struct AllowFriendAck {
	enum { MSG_ID = 5067 }; 
	uint32_t	seq;
	uint32_t	userseq;
	int16_t	result;
	uint16_t	is_allow;
	uint32_t	msgid;
	uint64_t	dummy;
	AllowFriendAck()	{
		seq = 0;
		userseq = 0;
		result = 0;
		is_allow = 0;
		msgid = 0;
		dummy = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint64_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = userseq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		(*(uint16_t*)(*_buf_)) = is_allow; (*_buf_) += sizeof(uint16_t);
		(*(uint32_t*)(*_buf_)) = msgid; (*_buf_) += sizeof(uint32_t);
		(*(uint64_t*)(*_buf_)) = dummy; (*_buf_) += sizeof(uint64_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&userseq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&is_allow, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&msgid, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint64_t) > nSize) { return false; }	std::memcpy(&dummy, *_buf_, sizeof(uint64_t));	(*_buf_) += sizeof(uint64_t); nSize -= sizeof(uint64_t);
		return true;
	}
}; //AllowFriendAck
struct AllowFriendAck_Serializer {
	static bool Store(char** _buf_, const AllowFriendAck& obj) { return obj.Store(_buf_); }
	static bool Load(AllowFriendAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const AllowFriendAck& obj) { return obj.Size(); }
};
struct InviteBlockSyn {
	enum { MSG_ID = 5068 }; 
	uint32_t	seq;
	uint16_t	invite_block;
	InviteBlockSyn()	{
		seq = 0;
		invite_block = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint16_t*)(*_buf_)) = invite_block; (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&invite_block, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //InviteBlockSyn
struct InviteBlockSyn_Serializer {
	static bool Store(char** _buf_, const InviteBlockSyn& obj) { return obj.Store(_buf_); }
	static bool Load(InviteBlockSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const InviteBlockSyn& obj) { return obj.Size(); }
};
struct InviteBlockAck {
	enum { MSG_ID = 5069 }; 
	uint32_t	seq;
	int16_t	result;
	uint16_t	invite_block;
	InviteBlockAck()	{
		seq = 0;
		result = 0;
		invite_block = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		(*(uint16_t*)(*_buf_)) = invite_block; (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&invite_block, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //InviteBlockAck
struct InviteBlockAck_Serializer {
	static bool Store(char** _buf_, const InviteBlockAck& obj) { return obj.Store(_buf_); }
	static bool Load(InviteBlockAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const InviteBlockAck& obj) { return obj.Size(); }
};
struct FriendShipBlockSyn {
	enum { MSG_ID = 5070 }; 
	uint32_t	seq;
	uint16_t	heart_block;
	FriendShipBlockSyn()	{
		seq = 0;
		heart_block = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint16_t*)(*_buf_)) = heart_block; (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&heart_block, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //FriendShipBlockSyn
struct FriendShipBlockSyn_Serializer {
	static bool Store(char** _buf_, const FriendShipBlockSyn& obj) { return obj.Store(_buf_); }
	static bool Load(FriendShipBlockSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const FriendShipBlockSyn& obj) { return obj.Size(); }
};
struct FriendShipBlockAck {
	enum { MSG_ID = 5071 }; 
	uint32_t	seq;
	int16_t	result;
	uint16_t	heart_block;
	FriendShipBlockAck()	{
		seq = 0;
		result = 0;
		heart_block = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		(*(uint16_t*)(*_buf_)) = heart_block; (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&heart_block, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //FriendShipBlockAck
struct FriendShipBlockAck_Serializer {
	static bool Store(char** _buf_, const FriendShipBlockAck& obj) { return obj.Store(_buf_); }
	static bool Load(FriendShipBlockAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const FriendShipBlockAck& obj) { return obj.Size(); }
};
struct InviteCountSyn {
	enum { MSG_ID = 5072 }; 
	uint32_t	seq;
	InviteCountSyn()	{
		seq = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //InviteCountSyn
struct InviteCountSyn_Serializer {
	static bool Store(char** _buf_, const InviteCountSyn& obj) { return obj.Store(_buf_); }
	static bool Load(InviteCountSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const InviteCountSyn& obj) { return obj.Size(); }
};
struct InviteCountAck {
	enum { MSG_ID = 5073 }; 
	uint32_t	seq;
	int16_t	result;
	uint16_t	invite_count;
	InviteCountAck()	{
		seq = 0;
		result = 0;
		invite_count = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		(*(uint16_t*)(*_buf_)) = invite_count; (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&invite_count, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //InviteCountAck
struct InviteCountAck_Serializer {
	static bool Store(char** _buf_, const InviteCountAck& obj) { return obj.Store(_buf_); }
	static bool Load(InviteCountAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const InviteCountAck& obj) { return obj.Size(); }
};
struct GachyaBoxSyn {
	enum { MSG_ID = 5076 }; 
	uint32_t	seq;
	uint32_t	box_open_point;
	GachyaBoxSyn()	{
		seq = 0;
		box_open_point = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = box_open_point; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&box_open_point, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //GachyaBoxSyn
struct GachyaBoxSyn_Serializer {
	static bool Store(char** _buf_, const GachyaBoxSyn& obj) { return obj.Store(_buf_); }
	static bool Load(GachyaBoxSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const GachyaBoxSyn& obj) { return obj.Size(); }
};
struct GachyaBoxAck {
	enum { MSG_ID = 5077 }; 
	uint32_t	seq;
	int16_t	result;
	uint32_t	heart_count;
	GachyaBoxAck()	{
		seq = 0;
		result = 0;
		heart_count = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		(*(uint32_t*)(*_buf_)) = heart_count; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&heart_count, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //GachyaBoxAck
struct GachyaBoxAck_Serializer {
	static bool Store(char** _buf_, const GachyaBoxAck& obj) { return obj.Store(_buf_); }
	static bool Load(GachyaBoxAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const GachyaBoxAck& obj) { return obj.Size(); }
};
struct LastWeekRankInfoSyn {
	enum { MSG_ID = 5078 }; 
	uint32_t	seq;
	LastWeekRankInfoSyn()	{
		seq = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //LastWeekRankInfoSyn
struct LastWeekRankInfoSyn_Serializer {
	static bool Store(char** _buf_, const LastWeekRankInfoSyn& obj) { return obj.Store(_buf_); }
	static bool Load(LastWeekRankInfoSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const LastWeekRankInfoSyn& obj) { return obj.Size(); }
};
struct LastWeekRankInfoAck {
	enum { MSG_ID = 5079 }; 
	uint32_t	seq;
	int16_t	result;
	int32_t	my_ranking;
	uint16_t	this_week_friend_count;
	uint16_t	last_week_friend_count;
	LastWeekRankInfoAck()	{
		seq = 0;
		result = 0;
		my_ranking = 0;
		this_week_friend_count = 0;
		last_week_friend_count = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(int32_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		(*(int32_t*)(*_buf_)) = my_ranking; (*_buf_) += sizeof(int32_t);
		(*(uint16_t*)(*_buf_)) = this_week_friend_count; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = last_week_friend_count; (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(int32_t) > nSize) { return false; }	std::memcpy(&my_ranking, *_buf_, sizeof(int32_t));	(*_buf_) += sizeof(int32_t); nSize -= sizeof(int32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&this_week_friend_count, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&last_week_friend_count, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //LastWeekRankInfoAck
struct LastWeekRankInfoAck_Serializer {
	static bool Store(char** _buf_, const LastWeekRankInfoAck& obj) { return obj.Store(_buf_); }
	static bool Load(LastWeekRankInfoAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const LastWeekRankInfoAck& obj) { return obj.Size(); }
};
struct AddHeartCountSyn {
	enum { MSG_ID = 5080 }; 
	uint32_t	seq;
	uint32_t	msgid;
	uint32_t	heart_count_max;
	uint16_t	get_heart_count;
	AddHeartCountSyn()	{
		seq = 0;
		msgid = 0;
		heart_count_max = 0;
		get_heart_count = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = msgid; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = heart_count_max; (*_buf_) += sizeof(uint32_t);
		(*(uint16_t*)(*_buf_)) = get_heart_count; (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&msgid, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&heart_count_max, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&get_heart_count, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //AddHeartCountSyn
struct AddHeartCountSyn_Serializer {
	static bool Store(char** _buf_, const AddHeartCountSyn& obj) { return obj.Store(_buf_); }
	static bool Load(AddHeartCountSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const AddHeartCountSyn& obj) { return obj.Size(); }
};
struct AddHeartCountAck {
	enum { MSG_ID = 5081 }; 
	uint32_t	seq;
	int16_t	result;
	uint32_t	msgid;
	uint32_t	heart_count;
	AddHeartCountAck()	{
		seq = 0;
		result = 0;
		msgid = 0;
		heart_count = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		(*(uint32_t*)(*_buf_)) = msgid; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = heart_count; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&msgid, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&heart_count, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //AddHeartCountAck
struct AddHeartCountAck_Serializer {
	static bool Store(char** _buf_, const AddHeartCountAck& obj) { return obj.Store(_buf_); }
	static bool Load(AddHeartCountAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const AddHeartCountAck& obj) { return obj.Size(); }
};
struct GetHeartCountSyn {
	enum { MSG_ID = 5082 }; 
	uint32_t	seq;
	GetHeartCountSyn()	{
		seq = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //GetHeartCountSyn
struct GetHeartCountSyn_Serializer {
	static bool Store(char** _buf_, const GetHeartCountSyn& obj) { return obj.Store(_buf_); }
	static bool Load(GetHeartCountSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const GetHeartCountSyn& obj) { return obj.Size(); }
};
struct GetHeartCountAck {
	enum { MSG_ID = 5083 }; 
	uint32_t	seq;
	int16_t	result;
	uint32_t	heart_count;
	GetHeartCountAck()	{
		seq = 0;
		result = 0;
		heart_count = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		(*(uint32_t*)(*_buf_)) = heart_count; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&heart_count, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //GetHeartCountAck
struct GetHeartCountAck_Serializer {
	static bool Store(char** _buf_, const GetHeartCountAck& obj) { return obj.Store(_buf_); }
	static bool Load(GetHeartCountAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const GetHeartCountAck& obj) { return obj.Size(); }
};
struct FriendKillTimerSyn {
	enum { MSG_ID = 5086 }; 
	uint32_t	seq;
	FriendKillTimerSyn()	{
		seq = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //FriendKillTimerSyn
struct FriendKillTimerSyn_Serializer {
	static bool Store(char** _buf_, const FriendKillTimerSyn& obj) { return obj.Store(_buf_); }
	static bool Load(FriendKillTimerSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const FriendKillTimerSyn& obj) { return obj.Size(); }
};
struct FriendKillTimerAck {
	enum { MSG_ID = 5087 }; 
	uint32_t	seq;
	int16_t	result;
	FriendKillTimerAck()	{
		seq = 0;
		result = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		return true;
	}
}; //FriendKillTimerAck
struct FriendKillTimerAck_Serializer {
	static bool Store(char** _buf_, const FriendKillTimerAck& obj) { return obj.Store(_buf_); }
	static bool Load(FriendKillTimerAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const FriendKillTimerAck& obj) { return obj.Size(); }
};
struct SendStaminaSyn {
	enum { MSG_ID = 5088 }; 
	uint32_t	seq;
	uint32_t	gid;
	uint16_t	is_push;
	uint16_t	send_heart_count;
	uint16_t	send_stamina_count;
	SendStaminaSyn()	{
		seq = 0;
		gid = 0;
		is_push = 0;
		send_heart_count = 0;
		send_stamina_count = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = gid; (*_buf_) += sizeof(uint32_t);
		(*(uint16_t*)(*_buf_)) = is_push; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = send_heart_count; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = send_stamina_count; (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&gid, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&is_push, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&send_heart_count, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&send_stamina_count, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //SendStaminaSyn
struct SendStaminaSyn_Serializer {
	static bool Store(char** _buf_, const SendStaminaSyn& obj) { return obj.Store(_buf_); }
	static bool Load(SendStaminaSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const SendStaminaSyn& obj) { return obj.Size(); }
};
struct SendStaminaAck {
	enum { MSG_ID = 5089 }; 
	uint32_t	seq;
	int16_t	result;
	SendStaminaAck()	{
		seq = 0;
		result = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		return true;
	}
}; //SendStaminaAck
struct SendStaminaAck_Serializer {
	static bool Store(char** _buf_, const SendStaminaAck& obj) { return obj.Store(_buf_); }
	static bool Load(SendStaminaAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const SendStaminaAck& obj) { return obj.Size(); }
};
struct ConfirmNewsV2Syn {
	enum { MSG_ID = 5090 }; 
	uint32_t	seq;
	uint32_t	gid;
	uint16_t	confirm_type;
	uint64_t	news_seq;
	uint16_t	news_type;
	uint16_t	max_heart;
	uint16_t	max_stamina;
	uint16_t	cur_stamina;
	uint16_t	remain_recv_stamina;
	uint16_t	max_recv_stamina;
	ConfirmNewsV2Syn()	{
		seq = 0;
		gid = 0;
		confirm_type = 0;
		news_seq = 0;
		news_type = 0;
		max_heart = 0;
		max_stamina = 0;
		cur_stamina = 0;
		remain_recv_stamina = 0;
		max_recv_stamina = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint64_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		nSize += sizeof(uint16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = gid; (*_buf_) += sizeof(uint32_t);
		(*(uint16_t*)(*_buf_)) = confirm_type; (*_buf_) += sizeof(uint16_t);
		(*(uint64_t*)(*_buf_)) = news_seq; (*_buf_) += sizeof(uint64_t);
		(*(uint16_t*)(*_buf_)) = news_type; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = max_heart; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = max_stamina; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = cur_stamina; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = remain_recv_stamina; (*_buf_) += sizeof(uint16_t);
		(*(uint16_t*)(*_buf_)) = max_recv_stamina; (*_buf_) += sizeof(uint16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&gid, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&confirm_type, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint64_t) > nSize) { return false; }	std::memcpy(&news_seq, *_buf_, sizeof(uint64_t));	(*_buf_) += sizeof(uint64_t); nSize -= sizeof(uint64_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&news_type, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&max_heart, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&max_stamina, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&cur_stamina, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&remain_recv_stamina, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		if(sizeof(uint16_t) > nSize) { return false; }	std::memcpy(&max_recv_stamina, *_buf_, sizeof(uint16_t));	(*_buf_) += sizeof(uint16_t); nSize -= sizeof(uint16_t);
		return true;
	}
}; //ConfirmNewsV2Syn
struct ConfirmNewsV2Syn_Serializer {
	static bool Store(char** _buf_, const ConfirmNewsV2Syn& obj) { return obj.Store(_buf_); }
	static bool Load(ConfirmNewsV2Syn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const ConfirmNewsV2Syn& obj) { return obj.Size(); }
};
struct ConfirmNewsV2Ack {
	enum { MSG_ID = 5091 }; 
	uint32_t	seq;
	int16_t	result;
	uint32_t	heart_count;
	uint32_t	charge_stamina_count;
	uint64_t	news_seq;
	ConfirmNewsV2Ack()	{
		seq = 0;
		result = 0;
		heart_count = 0;
		charge_stamina_count = 0;
		news_seq = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint32_t);
		nSize += sizeof(uint64_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		(*(uint32_t*)(*_buf_)) = heart_count; (*_buf_) += sizeof(uint32_t);
		(*(uint32_t*)(*_buf_)) = charge_stamina_count; (*_buf_) += sizeof(uint32_t);
		(*(uint64_t*)(*_buf_)) = news_seq; (*_buf_) += sizeof(uint64_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&heart_count, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&charge_stamina_count, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(uint64_t) > nSize) { return false; }	std::memcpy(&news_seq, *_buf_, sizeof(uint64_t));	(*_buf_) += sizeof(uint64_t); nSize -= sizeof(uint64_t);
		return true;
	}
}; //ConfirmNewsV2Ack
struct ConfirmNewsV2Ack_Serializer {
	static bool Store(char** _buf_, const ConfirmNewsV2Ack& obj) { return obj.Store(_buf_); }
	static bool Load(ConfirmNewsV2Ack& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const ConfirmNewsV2Ack& obj) { return obj.Size(); }
};
struct UnregisterSyn {
	enum { MSG_ID = 5092 }; 
	uint32_t	seq;
	UnregisterSyn()	{
		seq = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		return true;
	}
}; //UnregisterSyn
struct UnregisterSyn_Serializer {
	static bool Store(char** _buf_, const UnregisterSyn& obj) { return obj.Store(_buf_); }
	static bool Load(UnregisterSyn& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const UnregisterSyn& obj) { return obj.Size(); }
};
struct UnregisterAck {
	enum { MSG_ID = 5093 }; 
	uint32_t	seq;
	int16_t	result;
	UnregisterAck()	{
		seq = 0;
		result = 0;
	}
	int32_t Size() const {
		int32_t nSize = 0;
		nSize += sizeof(uint32_t);
		nSize += sizeof(int16_t);
		return nSize;
	}
	bool Store(std::vector<char>& _buf_) const {
		size_t nSize = Size();
 		if(0 == nSize) { return true; }
		if(nSize > _buf_.size()) { 
			_buf_.resize(nSize);
		}
		char* pBuf = &(_buf_[0]);
		if(false == Store(&pBuf)) return false;
		return true;
	}
	bool Store(char** _buf_) const {
		(*(uint32_t*)(*_buf_)) = seq; (*_buf_) += sizeof(uint32_t);
		(*(int16_t*)(*_buf_)) = result; (*_buf_) += sizeof(int16_t);
		return true;
	}
	bool Load(const std::vector<char>& _buf_) {
		size_t nSize = _buf_.size();
 		if(0 == nSize) { return true; }
		const char* pBuf = &(_buf_[0]);
		if(false == Load(&pBuf, nSize)) return false;
		return true;
	}
	bool Load(const char** _buf_, size_t& nSize) {
		if(sizeof(uint32_t) > nSize) { return false; }	std::memcpy(&seq, *_buf_, sizeof(uint32_t));	(*_buf_) += sizeof(uint32_t); nSize -= sizeof(uint32_t);
		if(sizeof(int16_t) > nSize) { return false; }	std::memcpy(&result, *_buf_, sizeof(int16_t));	(*_buf_) += sizeof(int16_t); nSize -= sizeof(int16_t);
		return true;
	}
}; //UnregisterAck
struct UnregisterAck_Serializer {
	static bool Store(char** _buf_, const UnregisterAck& obj) { return obj.Store(_buf_); }
	static bool Load(UnregisterAck& obj, const char** _buf_, size_t& nSize) { return obj.Load(_buf_, nSize); }
	static int32_t Size(const UnregisterAck& obj) { return obj.Size(); }
};
#endif // __iFriends_H__
